To help users find what they’re looking for straight from the search box, you can use Algolia Rules to automatically apply a filter to results if the query matches a facet value.

​
How to create a dynamic filtering rule

In this example for a product catalog, you create a rule that displays products with the “red” value in the color facet if the query contains the word “red”. Using the example dataset, this rule ensures that only records with “red” in the color attribute are returned. It ignores “red” in other attributes such as brand.
QueryResults
redFM, Clothing, LondonLook, Red, 21.99
The Mandal, Toaster, Black & Decker, Red, 149.99

​
Using the dashboard

  1. Go to the Algolia dashboard and select your Algolia application.
  2. On the left sidebar, select Search.
  3. Select your Algolia index:
  4. Click Rules in the left sidebar menu.
  5. Select Create your first rule or New rule. In the drop-down menu, click the Manual Editor option.
  6. In the Condition(s) section, with Query toggled on, select Contains in the drop-down menu, and enter “red” in the input field.
  7. In the Consequence(s) section:
    • Click Add consequence and select Add Query Parameter.
    • In the input field that appears, add the JSON parameters you want to apply when the user’s query matches the Rule: {"filters":"color:red"}
    • Click Add consequence and select Remove Word.
    • Type or select “red” in the input field.
If you click Optional under Consequence(s), this will display non-red products after the red ones. For more information, see Using optional filters.
  1. Save your changes.

​
Using the API

This example uses the filters parameter. With this approach, you need one rule per filter value. If you have 10 color options, you need 10 rules, one for each color. 
var rule = new Rule
{
    ObjectID = "red-color",
    Conditions = new List<Condition>
    {
        new Condition { Anchoring = "contains", Pattern = "red" }
    },
    Consequence = new Consequence
    {
        Params = new ConsequenceParams
        {
            Filters = "color:red",
            Query = new ConsequenceQuery { Edits = new List<Edit> { new Edit { Delete = "red" } } }
        }
    }
};

index.SaveRule(rule);

// Asynchronous
await index.SaveRuleAsync(rule);

​
Examples

The following examples explore:

​
One rule per facet

Instead of creating one rule per facet value, this approach uses one rule for the color facet. Using the example dataset, this single rule ensures that any record with any matching color value in the color attribute will be returned.
QueryResults
redFM, Clothing, LondonLook, Red, 21.99
The Mandal, Toaster, Black & Decker, Red, 149.99
blackWill Carpenter, T-shirt, Red or Dead, Black, 199.99

​
Using the dashboard

  1. Create a new rule. See how to create a dynamic filtering rule.
  2. In the Manual Editor’s Condition(s), click the box next to Query contains and select the option Add Facet “color” from the drop-down menu.
  3. In the Consequence(s) section:
    • Click Add consequence and select Filter/Boost Matching Attributes.
    • Click the Filter box that appears and select the option Add Facet “color” from the drop-down menu.
  4. Save your changes.

​
Using the API

var rule = new Rule
{
    ObjectID = "color-facets",
    Conditions = new List<Condition>
    {
        new Condition { Anchoring = "contains", Pattern = "facet:color" }
    },
    Consequence = new Consequence
    {
        Params = new ConsequenceParams
        {
            AutomaticFacetFilters = new List<AutomaticFacetFilter>
            {
                new AutomaticFacetFilter { Facet = "color" }
            }
        }
    }
};

index.SaveRule(rule);

// Asynchronous
await index.SaveRuleAsync(rule);

​
Numerical dynamic filtering

Consider a user entering the query “cheap toaster 800w”. You can use two rules together to filter results by:
  1. The product type: “Toaster”
  2. “Cheapness”. You determine that a cheap product is any product that costs less than $15.
Using the example dataset, these rules ensure that any product that costs less than $15, has the product_type “Toaster” and includes the phrase “800w” is returned.
QueryResults
cheap toaster 800wEssentials 800w, Toaster, Daewoo, Black, 14.99

​
Using the dashboard

Create the first rule:
  1. Create a new rule. See how to create a dynamic filtering rule.
  2. In the Manual Editor’s Condition(s), with Query toggled on, select Contains in the drop-down menu, and enter “toaster” in the input field.
  3. In the Consequence(s) section:
    • Click Add consequence and select Add Query Parameter.
    • In the input field that appears, enter {"filters":"product_type:toaster"}
    • Click Add consequence and select Remove Word.
    • Type or select “toaster” in the input field.
  4. Save your changes.
Create the second rule:
  1. Create a new rule
  2. In the Manual Editor’s Condition(s), with Query toggled on, select Contains in the drop-down menu, and enter “cheap” in the input field.
  3. In the Consequence(s) section:
    • Click Add consequence and select Add Query Parameter.
    • In the input field that appears, enter {"filters":"price < 10"}
    • Click Add consequence and select Remove Word.
    • Type or select “cheap” in the input field.
  4. Save your changes.

​
Using the API

var rules = new List<Rule>
{
    new Rule
    {
        ObjectID = "toaster",
        Conditions = new List<Condition>
        {
            new Condition { Anchoring = "contains", Pattern = "toaster" }
        },
        Consequence = new Consequence
        {
            Params = new ConsequenceParams
            {
                Filters = "product_type:toaster",
                Query = new ConsequenceQuery
                {
                    Edits = new List<Edit> { new Edit { Delete = "toaster" } }
                }
            }
        }
    },
    new Rule
    {
        ObjectID = "cheap",
        Conditions = new List<Condition>
        {
            new Condition { Anchoring = "contains", Pattern = "cheap" }
        },
        Consequence = new Consequence
        {
            Params = new ConsequenceParams
            {
                Filters = "price < 15",
                Query = new ConsequenceQuery
                {
                    Edits = new List<Edit> { new Edit { Delete = "cheap" } }
                }
            }
        }
    },
};

index.SaveRules(rules);

// Asynchronous
await index.SaveRulesAsync(rules);

​
Tagged filters

Consider a user who enters the query “apple headphones”. They would expect to search for results that match the term “headphones”, but only where the brand attribute matches “apple”. You can find this behavior on sites such as GitHub. It’s a great alternative to filters for users who prefer to type rather than click. This approach is similar to one rule per facet. Using the example dataset, this rule ensures that any record containing the phrase “headphones” that also has “Apple” in the brand attribute will be returned. It won’t return non-Apple brands, even if the phrase “Apple” appears in other attributes.
QueryResults
apple headphonesAirpods Max, Headphones, Apple, Gray, 548.99

​
Using the dashboard

  1. Create a new rule as above
  2. In the Manual Editor’s Condition(s), click the box next to Query contains and select the option Add Facet “brand” from the drop-down menu.
  3. Clear the Apply to plurals, synonyms and typos checkbox to ensure precise matching of the brand name.
  4. In the Consequence(s) section:
    • Click Add consequence and select Filter/Boost Matching Attributes.
    • Click the Filter box that appears and select the option Add Facet “brand” from the drop-down menu.
    • Click Add consequence and select Remove word.
    • In the input that appears, select Remove {facet:brand}.
  5. Save your changes.

​
Using the API

var rule = new Rule
{
    Condition = new Condition
    {
        Anchoring = "contains",
        Pattern = "brand\\: {facet:brand}",
        Alternatives = Alternatives.Of(false)
    },

    Consequence = new Consequence
    {
        Params = new ConsequenceParams
        {
            AutomaticFacetFilters = new List<AutomaticFacetFilter>
            {
                new AutomaticFacetFilter { Facet = "brand" }
            },
            Query = new ConsequenceQuery
            {
                Edits = new List<Edit>
                {
                    new Edit { Type = EditType.Remove, Delete = "brand\\:" },
                    new Edit { Type = EditType.Remove, Delete = "{facet:brand}" }
                }
            }
        }
    },
    Description = "filter on brand: {brand}",
    ObjectID = "tagged-brand-rule"
};

index.SaveRule(rule);

// Asynchronous
await index.SaveRuleAsync(rule);

​
Example dataset

All the examples on this page use a product catalog index. The appropriate attributes have been set as attributes for faceting. The index has records that look like this:
json
[
  {
    "product_name": "FM",
    "product_type": "T-shirt",
    "brand": "LondonLook",
    "color": "Red",
    "price": 21.99
  },
  {
    "product_name": "Caveman",
    "product_type": "T-shirt",
    "brand": "Red or Dead",
    "color": "Brown",
    "price": 9.99
  },
  {
    "product_name": "iPhone 13 Pro Max",
    "product_type": "Phone",
    "brand": "Apple",
    "color": "Blue",
    "price": 1824.61
  },
  {
    "product_name": "Will Carpenter",
    "product_type": "T-shirt",
    "brand": "Red or Dead",
    "color": "Black",
    "price": 199.99
  },
  {
    "product_name": "The Mandal 800w",
    "product_type": "Toaster",
    "brand": "Black & Decker",
    "color": "Red",
    "price": 149.99
  },
  {
    "product_name": "Essentials 800w",
    "product_type": "Toaster",
    "brand": "Daewoo",
    "color": "Black",
    "price": 14.99
  },
  {
    "product_name": "Airpods Max",
    "product_type": "Headphones",
    "brand": "Apple",
    "color": "Gray",
    "price": 548.99
  },
  {
    "product_name": "WH-CH520",
    "product_type": "Headphones",
    "brand": "Sony",
    "color": "Apple",
    "price": 39.99
  }
]

​
See also